home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / GL / flight / radar.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  11.5 KB  |  604 lines
  1. /*
  2.  * Copyright 1990, 1991, 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17.  
  18. /*
  19.  *  radar.c $Revision: 1.3 $
  20.  */
  21.  
  22. #include "flight.h"
  23. #include "udpbrdcst.h"
  24. #include <stdio.h>
  25.  
  26. #define MAX_RADAR_MODE 1
  27.  
  28. static char *buffers[MAX_PLANES+6];
  29. int do_send;
  30. int vcx, vcy;
  31. float stw, vsx, usx, usy, ucx, ucy;
  32.  
  33. int plane_colors[8] = {C_ORANGE, C_HBLUE, C_RED, C_WHITE,
  34.                C_BLUE, C_PURPLE_0, C_YELLOW, C_GREEN};
  35.  
  36. radar_hist_t radar_history[MAX_PLANES];
  37. int draging = FALSE;
  38.  
  39. int radar_mode;
  40. long old_mousex, old_mousey;
  41.  
  42.  
  43. void radar_start()
  44. {
  45.     char **msg;
  46.     int i;
  47.  
  48.     for (i = 0; i < MAX_PLANES; i++)
  49.     radar_history[i].id = NULL_PLANE_ID;
  50.  
  51.     debug = 0;
  52.     radar_mode = 1;
  53.     dogfight = 1;
  54.     ucx = 0.0;
  55.     ucy = 5000.0;
  56.     usx = 70000.0;
  57.     reset_winodow_size();
  58.     rebuild_ortho();
  59.  
  60.     for (msg = buffers;
  61.      msg < buffers+MAX_PLANES+6;
  62.      *msg++ = (char *)malloc(132));
  63. }
  64.  
  65.  
  66. void radar_loop()
  67. {
  68.     while (1)
  69.     {
  70.     /*
  71.      *  read all input commands
  72.      */
  73.     radar_read_queue();
  74.  
  75.     if (do_send)
  76.     {
  77.         char buf[132], prompt[80];
  78.         float fmx, fmy;
  79.         register Plane p;
  80.         extern int MSG_SIZE;
  81.  
  82.         fmx = (getvaluator(MOUSEX)-vcx) * stw + ucx;
  83.         fmy = (getvaluator(MOUSEY)-vcy) * stw + ucy;
  84.         if (do_send == MOUSE2)
  85.         {
  86.         get_text("Enter message to broadcast: ", buf, MSG_SIZE);
  87.         if (*buf)
  88.             broadcast(buf);
  89.         }
  90.         else if (p = radar_find_closest_plane(fmx, -fmy))
  91.         {
  92.         sprintf(prompt, "Enter message to send to %s: ", p->myname);
  93.         get_text(prompt, buf, MSG_SIZE);
  94.         if (*buf)
  95.             send_message(buf, PLANE_ID(p));
  96.         }
  97.         do_send = FALSE;
  98.     }
  99.  
  100.     /*
  101.      *  start up the screen clear
  102.      */
  103.     switch (radar_mode)
  104.     {
  105.         case 0:
  106.         reshapeviewport();
  107.         COLOR(C_BLUE);
  108.         clear();
  109.         break;
  110.         case 1:
  111.         reshapeviewport();
  112.         COLOR(C_BLACK);
  113.         clear();
  114.         break;
  115.     }
  116.  
  117.     /*
  118.      *  read all packets that are there
  119.      */
  120.     get_indata(1);            /* read new data */
  121.     gather_radar_history();        /* copy data into radar_hist */
  122.  
  123.     /*
  124.      *  draw the screen
  125.      */
  126.     switch (radar_mode)
  127.     {
  128.         case 0:
  129.         radar_text();
  130.         break;
  131.         case 1:
  132.         if (draging)
  133.         {
  134.             mousex = getvaluator(MOUSEX);
  135.             mousey = getvaluator(MOUSEY);
  136.             do_pan(stw * (old_mousex - mousex),
  137.                stw * (old_mousey - mousey));
  138.             old_mousex = mousex;
  139.             old_mousey = mousey;
  140.         }
  141.         radar_picture();
  142.         break;
  143.     }
  144.  
  145.     /*
  146.      *  display any network messages
  147.      */
  148.     ortho2(-200.0, 200.0, -300.0, 100.0);
  149.     draw_messages();
  150.  
  151.     swapbuffers();
  152.     }
  153. }
  154.  
  155.  
  156. void radar_read_queue()
  157. {
  158.     short type, val;
  159.  
  160.     /*
  161.      *  read all input commands
  162.      */
  163.     while (qtest())
  164.     {
  165.     switch (type = qread(&val))
  166.     {
  167.         case REDRAW:
  168.         reset_winodow_size();
  169.         rebuild_ortho();
  170.         break;
  171.         case INPUTCHANGE:
  172.         if (!val)
  173.             draging = FALSE;
  174.         break;
  175.         case KEYBD:
  176.         switch (val)
  177.         {
  178.             case 27:        /* ESC */
  179.             end_of_program();
  180.             break;
  181.             case 'x':
  182.             case 'z':
  183.             if (radar_mode == 1)
  184.             {
  185.                 if (val == 'x')
  186.                 usx *= .9;
  187.                 else
  188.                 usx /= .9;
  189.                 rebuild_ortho();
  190.             }
  191.             break;
  192.             case 'h':
  193.             show_help = !show_help;
  194.             break;
  195.             case ' ':
  196.             radar_mode++;
  197.             if (radar_mode > MAX_RADAR_MODE)
  198.                 radar_mode = 0;
  199.             break;
  200. #ifdef DEBUG
  201.             default:
  202.             if (val >= '0' && val <= '9')
  203.                 debug ^= 1 << (val-'0');
  204.             break;
  205. #endif
  206.         }
  207.         break;
  208.         case MOUSE1:
  209.         draging = val;
  210.         if (val && radar_mode == 1)
  211.         {
  212.             old_mousex = getvaluator(MOUSEX);
  213.             old_mousey = getvaluator(MOUSEY);
  214.         }
  215.         break;
  216.         case MOUSE2:
  217.         case MOUSE3:
  218.         if (val && radar_mode == 1)
  219.             do_send = type;
  220.         break;
  221.         case LEFTARROWKEY:
  222.         if (val && radar_mode == 1)
  223.             do_pan(-10000.0, 0.0);
  224.         break;
  225.         case RIGHTARROWKEY:
  226.         if (val && radar_mode == 1)
  227.             do_pan(10000.0, 0.0);
  228.         break;
  229.         case UPARROWKEY:
  230.         if (val && radar_mode == 1)
  231.             do_pan(0.0, 10000.0);
  232.         break;
  233.         case DOWNARROWKEY:
  234.         if (val && radar_mode == 1)
  235.             do_pan(0.0, -10000.0);
  236.         break;
  237.     }
  238.     }
  239. }
  240.  
  241.  
  242. void reset_winodow_size()
  243. {
  244.     long xorig, yorig, xsize, ysize;
  245.  
  246.     getsize(&xsize, &ysize);
  247.     getorigin(&xorig, &yorig);
  248.     vsx = xsize/2-1;
  249.     vcx = xsize/2 + xorig;
  250.     vcy = ysize/2 + yorig;
  251. }
  252.  
  253.  
  254. void rebuild_ortho()
  255. {
  256.     usy = usx * (YMAXSCREEN+1.0)/(XMAXSCREEN+1.0);
  257.     stw = usx/vsx;
  258. }
  259.  
  260.  
  261. void do_pan(float dx, float dy)
  262. {
  263.     ucx += dx;
  264.     ucy += dy;
  265.     rebuild_ortho();
  266. }
  267.  
  268.  
  269. void reset_radar_hist(radar_hist_t *rh)
  270. {
  271.     register int i;
  272.  
  273.     rh->velocity = 0;
  274.     rh->vx = 0.0;
  275.     rh->vy = 0.0;
  276.     rh->vz = 0.0;
  277.     for (i=0; i<RADAR_HISTORY; i++)
  278.     rh->status[i] = 0;
  279. }
  280.  
  281.  
  282. /*
  283.  *  find and return the closest plane to me
  284.  */
  285. Plane radar_find_closest_plane(float x, float z)
  286. {
  287.     register float d, dbest, temp;
  288.     register Plane p, *pp, pbest;
  289.  
  290.     pbest = NULL;
  291.     dbest = 1e30;
  292.  
  293.     FOR_EACH_PLANE (p, pp)        /* for each plane    */
  294.     {
  295.     d = x - p->x;            /* compute distance    */
  296.     temp = z - p->z;
  297.     d = d*d + temp*temp;
  298.     if (d < dbest)            /* and compare with best */
  299.     {
  300.         dbest = d;
  301.         pbest = p;
  302.     }
  303.     }
  304.     return(pbest);
  305. }
  306.  
  307.  
  308. radar_hist_t *findit(Plane p)
  309. {
  310.     register long i, id;
  311.  
  312.     id = PLANE_ID(p);
  313.     for (i=0; i < MAX_PLANES; i++)
  314.     if (id == radar_history[i].id)
  315.         return(&radar_history[i]);
  316.  
  317.     printf("Oops: fatal error, findit &d, %s failed\n", id, p->myname);
  318.     end_of_program();
  319. }
  320.  
  321.  
  322. void radar_text()
  323. {
  324.     register char **msg;
  325.     register Plane p, *pp;
  326.  
  327.     msg = buffers;
  328.     sprintf(*msg++, "  IP address        Name         (type,al)  Ver Status Won Lost       Position              Angles       MS MT");
  329.     sprintf(*msg++, "---------------- --------------- ---------- --- ------ --- ---- ----------------------  --------------  --- --");
  330.  
  331.     FOR_EACH_PLANE (p, pp)
  332.     {
  333.     sprintf(*msg++,
  334.         "%-16s %-15s (%4d,%3d)  %2d %6d %3d %4d %6d %6d %6d    %4d %4d %4d  %3d %2d",
  335.         inet_ntoa(p->planeid),
  336.         p->myname,
  337.         p->type, p->alive, p->version,
  338.         p->status, p->won, p->lost,
  339.         (int)p->x, (int)p->y, (int)p->z,
  340.         p->azimuth, p->elevation, p->twist,
  341.         p->mstatus, p->mtype);
  342.     }
  343.     sprintf(*msg, "");
  344.     COLOR(C_BLUE);
  345.     clear();
  346.     display_message_no_wait(buffers, 1);
  347. }
  348.  
  349.  
  350. void gather_radar_history()
  351. {
  352.     char *plane_name;
  353.     register int tick, dt;
  354.     register Plane p, *pp;
  355.     register radar_hist_t *rh;
  356.     float fps_knots;            /* fps to knots conversion factor */
  357.     float temp;
  358.  
  359.     FOR_EACH_PLANE (p, pp)
  360.     {
  361.     if (p->tps > 0.0)
  362.         fps_knots = p->tps * 3600.0/6082.0;
  363.     else
  364.         fps_knots = 20 * 3600.0/6082.0;
  365.  
  366.     rh = findit(p);
  367.     tick = rh->n;
  368.  
  369.     if (p->status == 0)
  370.         reset_radar_hist(rh);
  371.     else if ((dt=rh->status[tick]) != p->status)
  372.     {
  373.         dt = p->status - dt;    /* compute delta time    */
  374.         if (dt <= 0)        /* compute velocities    */
  375.         {
  376.         rh->vx = 0.0;
  377.         rh->vy = 0.0;
  378.         rh->vz = 0.0;
  379.         }
  380.         else
  381.         {
  382.         temp = 1.0/dt;
  383.         rh->vx = (p->x - rh->x[tick]) * temp;
  384.         rh->vy = (p->y - rh->y[tick]) * temp;
  385.         rh->vz = (p->z - rh->z[tick]) * temp;
  386.         }
  387.         rh->velocity = fps_knots * sqrt(rh->vx * rh->vx +
  388.                         rh->vy * rh->vy +
  389.                         rh->vz * rh->vz);
  390.  
  391.         /*
  392.          *  copy current data into data array
  393.          */
  394.         tick++;
  395.         if (tick >= RADAR_HISTORY)
  396.         tick = 0;
  397.         rh->n = tick;
  398.         rh->status[tick] = p->status;
  399.         rh->x[tick] = p->x;
  400.         rh->y[tick] = p->y;
  401.         rh->z[tick] = p->z;
  402.     }
  403.  
  404.     switch (p->type)
  405.     {
  406.         case C150:
  407.         plane_name = C150_NAME;
  408.         break;
  409.         case B747:
  410.         plane_name = B747_NAME;
  411.         break;
  412.         case F15:
  413.         plane_name = F15_NAME;
  414.         break;
  415.         case F16:
  416.         plane_name = F16_NAME;
  417.         break;
  418.         case F18:
  419.         plane_name = F18_NAME;
  420.         break;
  421.         case P38:
  422.         plane_name = P38_NAME;
  423.         break;
  424.         case F14:
  425.         plane_name = F14_NAME;
  426.         break;
  427.         case B727:
  428.         plane_name = B727_NAME;
  429.         break;
  430.     }
  431.  
  432.     sprintf(rh->buf, "%s:%d%c%03d",
  433.         plane_name,
  434.         rh->velocity,
  435.         (rh->vy >= 0.0) ? '+' : '-',
  436.         (int)(.01 * p->y));
  437.     }
  438. }
  439.  
  440.  
  441. void radar_picture()
  442. {
  443.     int plane_color;
  444.     register int i;
  445.     float y, dy;            /* height of text in user space */
  446.     register Plane p, *pp;
  447.     register radar_hist_t *rh;
  448.  
  449.     ortho2(ucx-usx, ucx+usx, ucy-usy, ucy+usy);
  450.     pushmatrix();
  451.  
  452.     plane_color = 0;
  453.     dy = 1.4 * getheight() * stw;    /* char height in user space */
  454.     draw_radar_world();
  455.  
  456.     scale(1.0, -1.0, 1.0);
  457.  
  458.     /*
  459.      *  draw planes
  460.      */
  461.     FOR_EACH_PLANE (p, pp)
  462.     {
  463.     rh = findit(p);
  464.     COLOR(plane_colors[plane_color++]);
  465.     plane_color &= 0x7;
  466.  
  467.     /*
  468.      *  draw history dots
  469.      */
  470.     for (i = 0; i < RADAR_HISTORY; i+= int_tps)
  471.         if (rh->status[i])
  472.         pnt2(rh->x[i], rh->z[i]);
  473.  
  474.     y = p->z;
  475.     pushmatrix();
  476.     translate(p->x, y, 0.0);
  477.     rotate(-p->azimuth, 'z');
  478.     draw_triangle();
  479.     popmatrix();
  480.  
  481.     /*
  482.      *  draw velocity vector
  483.      */
  484.     pnt2(p->x, y);
  485.     draw2(p->x + RADAR_HISTORY/2*rh->vx, y + RADAR_HISTORY/2*rh->vz);
  486.  
  487.     cmov2(p->x, y += 1.4*dy);
  488.     charstr(p->myname);
  489.  
  490.     cmov2(p->x, y += dy);
  491.     charstr(rh->buf);
  492.  
  493.     /*
  494.      *  display missile if its active
  495.      */
  496.     if (p->mstatus > 0)
  497.     {
  498.         if (p->mtype == TYPE_CANNON)
  499.         COLOR(C_YELLOW);
  500.         else if (p->mtype == TYPE_SIDEWINDER)
  501.         COLOR(C_RED);
  502.         else
  503.         COLOR(C_ORANGE);
  504.         pushmatrix();
  505.         translate(p->mx, p->mz, 0.0);
  506.         draw_projectile();
  507.         popmatrix();
  508.     }
  509.     }
  510.  
  511.     popmatrix();
  512.  
  513.     if (show_help)
  514.     overlay_radar_help();
  515. }
  516.  
  517.  
  518. void draw_radar_world()
  519. {
  520.     static long airport[12*4][2] =
  521.         {{ -700, 3100}, { -700, 3300}, { -100, 4000}, { -100, 3800},
  522.          { -700, 4700}, { -700, 4900}, { -100, 4200}, { -100, 4000},
  523.          { -700, 8400}, { -100, 8400}, { -100, 8500}, { -700, 8500},
  524.          { -700, 5900}, { -100, 5900}, { -100, 6000}, { -700, 6000},
  525.          {-1200, 4700}, { -800, 4700}, { -800, 4900}, {-1200, 4900},
  526.          {-1200, 3100}, { -800, 3100}, { -800, 3300}, {-1200, 3300},
  527.          {-1200, 2000}, {  700, 2000}, {  700, 2100}, {-1200, 2100},
  528.          { -700,    0}, { -100,    0}, { -100,  100}, { -700,  100},
  529.          {-2000, 2000}, {-1200, 2000}, {-1200, 4900}, {-2000, 4900},
  530.          {  700, 1600}, { 1000, 1600}, { 1000, 2500}, {  700, 2500},
  531.          { -800,    0}, { -700,    0}, { -700, 8500}, { -800, 8500},
  532.          { -100,    0}, {  100,    0}, {  100, 8500}, { -100, 8500}};
  533.     register int i;
  534.  
  535.     /*
  536.      *  grid
  537.      */
  538.     COLOR(C_DIRT);
  539.     for (i = -55000; i <= 55000; i += 10000)
  540.     {
  541.     move2i(i, -50000);
  542.     draw2i(i, 50000);
  543.     }
  544.     for (i = -50000; i <= 50000; i += 10000)
  545.     {
  546.     move2i(-55000, i);
  547.     draw2i(55000, i);
  548.     }
  549.  
  550.     /*
  551.      *  airport
  552.      */
  553.     COLOR(C_GREY_8);
  554.     for (i = 0; i < (12*4); i+=4)
  555.     {
  556.     bgnpolygon();
  557.     v2i(airport[i]);
  558.     v2i(airport[i+1]);
  559.     v2i(airport[i+2]);
  560.     v2i(airport[i+3]);
  561.     endpolygon();
  562.  
  563.     bgnclosedline();
  564.     v2i(airport[i]);
  565.     v2i(airport[i+1]);
  566.     v2i(airport[i+2]);
  567.     v2i(airport[i+3]);
  568.     endclosedline();
  569.     }
  570. }
  571.  
  572.  
  573. void draw_projectile()
  574. {
  575.     static long projectile[6][2] = {{-100,    0}, { -50,  100}, {  50,  100},
  576.                     { 100,    0}, {  50, -100}, { -50, -100}};
  577.  
  578.     bgnpolygon();
  579.     v2i(projectile[0]);
  580.     v2i(projectile[1]);
  581.     v2i(projectile[2]);
  582.     v2i(projectile[3]);
  583.     endpolygon();
  584.  
  585.     bgnpolygon();
  586.     v2i(projectile[0]);
  587.     v2i(projectile[3]);
  588.     v2i(projectile[4]);
  589.     v2i(projectile[5]);
  590.     endpolygon();
  591. }
  592.  
  593.  
  594. void draw_triangle()
  595. {
  596.     static long triangle[3][2] = {{0, 0}, {-200, 800}, {200, 800}};
  597.  
  598.     bgnclosedline();
  599.     v2i(triangle[0]);
  600.     v2i(triangle[1]);
  601.     v2i(triangle[2]);
  602.     endclosedline();
  603. }
  604.